Characterization of the Ceara Costal Zone Organic Matter Inputs

International audienceMangroves are extremely sensitive to the global climate change and urbanization impacts. To understand the effect of the urbanization on the organic matter of the coastal zone of Ceará State in north eastern Brazil, a seasonal filed campaigns were carried on in two most environmentally significant river/mangrove systems in the region; the Cocó river, in the metropolitan region of the huge city of Fortaleza, and the Pacoti River, an environmental protection area, without urban influence, on the east coast of the state. A spatial study was also done along the Jaguaribe river, which is the largest river in the state also connected to the largest mangrove area. Organic matter characterization by dissolved organic carbon, spectrofluorescence and fluorescence quenching and metal complexation capacity shows clearly that under urban pressure, the produced organic matter in mangrove area is different, meaning that carbon budget and pollutant fate have to be revised to take in account this difference

Mining System Specific Rules from Change Patterns

International audienceA significant percentage of warnings reported by tools to detect coding standard violations are false positives. Thus, there are some works dedicated to provide better rules by mining them from source code history, analyzing bug-fixes or changes between system releases. However, software evolves over time, and during development not only bugs are fixed, but also features are added, and code is refactored. In such cases, changes must be consistently applied in source code to avoid maintenance problems. In this paper, we propose to extract system specific rules by mining systematic changes over source code history, i.e., not just from bug-fixes or system releases, to ensure that changes are consistently applied over source code. We focus on structural changes done to support API modification or evolution with the goal of providing better rules to developers. Also, rules are mined from predefined rule patterns that ensure their quality. In order to assess the precision of such specific rules to detect real violations, we compare them with generic rules provided by tools to detect coding standard violations on four real world systems covering two programming languages. The results show that specific rules are more precise in identifying real violations in source code than generic ones, and thus can complement them

APIEvolutionMiner: Keeping API Evolution under Control

International audienceDuring software evolution, source code is constantly refactored. In real-world migrations, many methods in the newer version are not present in the old version (e.g., 60% of the methods in Eclipse 2.0 were not in version 1.0). This requires changes to be consistently applied to reflect the new API and avoid further maintenance problems. In this paper, we propose a tool to extract rules by monitoring API changes applied in source code during system evolution. In this process, changes are mined at revision level in code history. Our tool focuses on mining invocation changes to keep track of how they are evolving. We also provide three case studies in order to evaluate the tool

APIEvolutionMiner: Keeping API Evolution under Control

International audienceDuring software evolution, source code is constantly refactored. In real-world migrations, many methods in the newer version are not present in the old version (e.g., 60% of the methods in Eclipse 2.0 were not in version 1.0). This requires changes to be consistently applied to reflect the new API and avoid further maintenance problems. In this paper, we propose a tool to extract rules by monitoring API changes applied in source code during system evolution. In this process, changes are mined at revision level in code history. Our tool focuses on mining invocation changes to keep track of how they are evolving. We also provide three case studies in order to evaluate the tool

A Systematic Review and Discussion of the Clinical Potential

Funding Information: Funding by Portuguese Foundation for Science and Technology (FCT-MCTES) under the following projects: PTDC/EMD-EMD/1230/2021—Fluid-structure interaction for functional assessment of ascending aortic aneurysms: a biomechanical-based approach toward clinical practice ; UNIDEMI UIDB/00667/2020; A. Mourato PhD grant UI/BD/151212/2021; R. Valente PhD grant 2022.12223.BD. Publisher Copyright: © 2022 by the authors.Aortic aneurysm is a cardiovascular disease related to the alteration of the aortic tissue. It is an important cause of death in developed countries, especially for older patients. The diagnosis and treatment of such pathology is performed according to guidelines, which suggest surgical or interventional (stenting) procedures for aneurysms with a maximum diameter above a critical threshold. Although conservative, this clinical approach is also not able to predict the risk of acute complications for every patient. In the last decade, there has been growing interest towards the development of advanced in silico aortic models, which may assist in clinical diagnosis, surgical procedure planning or the design and validation of medical devices. This paper details a comprehensive review of computational modelling and simulations of blood vessel interaction in aortic aneurysms and dissection, following the Preferred Reporting Items for Systematic Reviews and Meta-Analyses (PRISMA). In particular, the following questions are addressed: “What mathematical models were applied to simulate the biomechanical behaviour of healthy and diseased aortas?” and “Why are these models not clinically implemented?”. Contemporary evidence proves that computational models are able to provide clinicians with additional, otherwise unavailable in vivo data and potentially identify patients who may benefit from earlier treatment. Notwithstanding the above, these tools are still not widely implemented, primarily due to low accuracy, an extensive reporting time and lack of numerical validation.publishersversionpublishe

Automatic Detection of System-Specific Conventions Unknown to Developers

International audienceIn Apache Ant, a convention to improve maintenance was introduced in 2004 stating a new way to close files instead of the Java generic InputStream.close(). Yet, six years after its introduction, this convention was still not generally known to the developers. Two existing solutions could help in these cases. First, one can deprecate entities, but, in our example, one can hardly deprecate Java's method. Second, one can create a system-specific rule to be automatically enforced. In a preceding publication , we showed that system-specific rules are more likely to be noticed by developers than generic ones. However, in practice, developers rarely create specific rules. We therefore propose to free the developers from the need to create rules by automatically detecting such conventions from source code repositories. This is done by mining the change history of the system to discover similar changes being applied over several revisions. The proposed approach is applied to real-world systems, and the extracted rules are validated with the help of experts. The results show that many rules are in fact relevant for the experts

System Specific, Source Code Transformations

International audienceDuring its lifetime, a software system might undergo a major transformation effort in its structure, for example to migrate to a new architecture or bring some drastic improvements to the system. Particularly in this context, we found evidences that some sequences of code changes are made in a systematic way. These sequences are composed of small code transformations (e.g., create a class, move a method) which are repeatedly applied to groups of related entities (e.g., a class and some of its methods). A typical example consists in the systematic introduction of a Factory design pattern on the classes of a package. We define these sequences as transformation patterns. In this paper, we identify examples of transformation patterns in real world software systems and study their properties: (i) they are specific to a system; (ii) they were applied manually; (iii) they were not always applied to all the software entities which could have been transformed; (iv) they were sometimes complex; and (v) they were not always applied in one shot but over several releases. These results suggest that transformation patterns could benefit from automated support in their application. From this study, we propose as future work to develop a macro recorder, a tool with which a developer records a sequence of code transformations and then automatically applies them in other parts of the system as a customizable, large-scale transformation operator

Recording and Replaying System Specific, Source Code Transformations

International audienceDuring its lifetime, a software system is under continuous maintenance to remain useful. Maintenance can be achieved in activities such as adding new features, fixing bugs, improving the system's structure, or adapting to new APIs. In such cases, developers sometimes perform sequences of code changes in a systematic way. These sequences consist of small code changes (e.g., create a class, then extract a method to this class), which are applied to groups of related code entities (e.g., some of the methods of a class). This paper presents the design and proof-of-concept implementation of a tool called MacroRecorder. This tool records a sequence of code changes, then it allows the developer to generalize this sequence in order to apply it in other code locations. In this paper, we discuss MacroRecorder's approach that is independent of both development and transformation tools. The evaluation is based on previous work on repetitive code changes related to rearchitecting. MacroRecorder was able to replay 92% of the examples, which consisted in up to seven code entities modified up to 66 times. The generation of a customizable, large-scale transformation operator has the potential to efficiently assist code maintenance